+2000-10-23 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testtext.c: Re-enable the "find" dialog
+
+ * gtk/testgtk.c: Add test for gdk_drawable_get_image
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix bug where
+ the arguments to gdk_draw_drawable were in the wrong order
+ (gdk_window_paint_init_bg): This function was ignoring the
+ init_region, instead of clipping to it, so the entire backing
+ pixmap was cleared on every begin_paint()
+ (gdk_window_begin_paint_region): Hmm, the same list-walking bug
+ was in here again, the loop kept using the same GtkWindowPaint
+ over and over.
+ (gdk_window_begin_paint_region): Fix a bug where we had two
+ x_offset instead of x_offset and y_offset
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): get composite drawable
+ before we get the image.
+ (gdk_draw_drawable): get the composite before we draw the drawable.
+ (gdk_drawable_real_get_composite_drawable): default
+ get_composite_drawable implementation that returns the drawable
+ itself
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Add
+ get_composite_drawable virtual function
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix a cheesy
+ list-walking bug
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_x11_draw_drawable): Add a hack to
+ make this work if the source drawable is a GdkDrawableImplX11
+ instead of a public drawable type. This is really broken; the
+ problem is that GdkDrawable needs a virtual method get_xid(), but
+ of course that doesn't work in practice. Enter RTTI.
+
+ Also, improve mismatched depth message.
+
+ * gdk/gdkpixmap.c (gdk_pixmap_get_image): Implement get_image for
+ GdkPixmap
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_drawable_impl_x11_class_init):
+ install _gdk_x11_get_image as our implementation of get_image
+
+ * gdk/x11/gdkimage-x11.c (gdk_image_get): Rename to
+ _gdk_x11_get_image and export for use in gdkdrawable-x11.c
+
+ * gdk/gdkimage.c (gdk_image_get): Make this just a wrapper around
+ gdk_drawable_get_image
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): call virtual get_image
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Virtualize
+ get_image
+
+ * gtk/gtktreestore.c (gtk_tree_store_get_node): remove weird
+ trailing semicolon after for loop
+
Mon Oct 23 12:07:57 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_set_style_internal): Fix problem
+2000-10-23 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testtext.c: Re-enable the "find" dialog
+
+ * gtk/testgtk.c: Add test for gdk_drawable_get_image
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix bug where
+ the arguments to gdk_draw_drawable were in the wrong order
+ (gdk_window_paint_init_bg): This function was ignoring the
+ init_region, instead of clipping to it, so the entire backing
+ pixmap was cleared on every begin_paint()
+ (gdk_window_begin_paint_region): Hmm, the same list-walking bug
+ was in here again, the loop kept using the same GtkWindowPaint
+ over and over.
+ (gdk_window_begin_paint_region): Fix a bug where we had two
+ x_offset instead of x_offset and y_offset
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): get composite drawable
+ before we get the image.
+ (gdk_draw_drawable): get the composite before we draw the drawable.
+ (gdk_drawable_real_get_composite_drawable): default
+ get_composite_drawable implementation that returns the drawable
+ itself
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Add
+ get_composite_drawable virtual function
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix a cheesy
+ list-walking bug
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_x11_draw_drawable): Add a hack to
+ make this work if the source drawable is a GdkDrawableImplX11
+ instead of a public drawable type. This is really broken; the
+ problem is that GdkDrawable needs a virtual method get_xid(), but
+ of course that doesn't work in practice. Enter RTTI.
+
+ Also, improve mismatched depth message.
+
+ * gdk/gdkpixmap.c (gdk_pixmap_get_image): Implement get_image for
+ GdkPixmap
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_drawable_impl_x11_class_init):
+ install _gdk_x11_get_image as our implementation of get_image
+
+ * gdk/x11/gdkimage-x11.c (gdk_image_get): Rename to
+ _gdk_x11_get_image and export for use in gdkdrawable-x11.c
+
+ * gdk/gdkimage.c (gdk_image_get): Make this just a wrapper around
+ gdk_drawable_get_image
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): call virtual get_image
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Virtualize
+ get_image
+
+ * gtk/gtktreestore.c (gtk_tree_store_get_node): remove weird
+ trailing semicolon after for loop
+
Mon Oct 23 12:07:57 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_set_style_internal): Fix problem
+2000-10-23 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testtext.c: Re-enable the "find" dialog
+
+ * gtk/testgtk.c: Add test for gdk_drawable_get_image
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix bug where
+ the arguments to gdk_draw_drawable were in the wrong order
+ (gdk_window_paint_init_bg): This function was ignoring the
+ init_region, instead of clipping to it, so the entire backing
+ pixmap was cleared on every begin_paint()
+ (gdk_window_begin_paint_region): Hmm, the same list-walking bug
+ was in here again, the loop kept using the same GtkWindowPaint
+ over and over.
+ (gdk_window_begin_paint_region): Fix a bug where we had two
+ x_offset instead of x_offset and y_offset
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): get composite drawable
+ before we get the image.
+ (gdk_draw_drawable): get the composite before we draw the drawable.
+ (gdk_drawable_real_get_composite_drawable): default
+ get_composite_drawable implementation that returns the drawable
+ itself
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Add
+ get_composite_drawable virtual function
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix a cheesy
+ list-walking bug
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_x11_draw_drawable): Add a hack to
+ make this work if the source drawable is a GdkDrawableImplX11
+ instead of a public drawable type. This is really broken; the
+ problem is that GdkDrawable needs a virtual method get_xid(), but
+ of course that doesn't work in practice. Enter RTTI.
+
+ Also, improve mismatched depth message.
+
+ * gdk/gdkpixmap.c (gdk_pixmap_get_image): Implement get_image for
+ GdkPixmap
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_drawable_impl_x11_class_init):
+ install _gdk_x11_get_image as our implementation of get_image
+
+ * gdk/x11/gdkimage-x11.c (gdk_image_get): Rename to
+ _gdk_x11_get_image and export for use in gdkdrawable-x11.c
+
+ * gdk/gdkimage.c (gdk_image_get): Make this just a wrapper around
+ gdk_drawable_get_image
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): call virtual get_image
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Virtualize
+ get_image
+
+ * gtk/gtktreestore.c (gtk_tree_store_get_node): remove weird
+ trailing semicolon after for loop
+
Mon Oct 23 12:07:57 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_set_style_internal): Fix problem
+2000-10-23 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testtext.c: Re-enable the "find" dialog
+
+ * gtk/testgtk.c: Add test for gdk_drawable_get_image
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix bug where
+ the arguments to gdk_draw_drawable were in the wrong order
+ (gdk_window_paint_init_bg): This function was ignoring the
+ init_region, instead of clipping to it, so the entire backing
+ pixmap was cleared on every begin_paint()
+ (gdk_window_begin_paint_region): Hmm, the same list-walking bug
+ was in here again, the loop kept using the same GtkWindowPaint
+ over and over.
+ (gdk_window_begin_paint_region): Fix a bug where we had two
+ x_offset instead of x_offset and y_offset
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): get composite drawable
+ before we get the image.
+ (gdk_draw_drawable): get the composite before we draw the drawable.
+ (gdk_drawable_real_get_composite_drawable): default
+ get_composite_drawable implementation that returns the drawable
+ itself
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Add
+ get_composite_drawable virtual function
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix a cheesy
+ list-walking bug
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_x11_draw_drawable): Add a hack to
+ make this work if the source drawable is a GdkDrawableImplX11
+ instead of a public drawable type. This is really broken; the
+ problem is that GdkDrawable needs a virtual method get_xid(), but
+ of course that doesn't work in practice. Enter RTTI.
+
+ Also, improve mismatched depth message.
+
+ * gdk/gdkpixmap.c (gdk_pixmap_get_image): Implement get_image for
+ GdkPixmap
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_drawable_impl_x11_class_init):
+ install _gdk_x11_get_image as our implementation of get_image
+
+ * gdk/x11/gdkimage-x11.c (gdk_image_get): Rename to
+ _gdk_x11_get_image and export for use in gdkdrawable-x11.c
+
+ * gdk/gdkimage.c (gdk_image_get): Make this just a wrapper around
+ gdk_drawable_get_image
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): call virtual get_image
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Virtualize
+ get_image
+
+ * gtk/gtktreestore.c (gtk_tree_store_get_node): remove weird
+ trailing semicolon after for loop
+
Mon Oct 23 12:07:57 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_set_style_internal): Fix problem
+2000-10-23 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testtext.c: Re-enable the "find" dialog
+
+ * gtk/testgtk.c: Add test for gdk_drawable_get_image
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix bug where
+ the arguments to gdk_draw_drawable were in the wrong order
+ (gdk_window_paint_init_bg): This function was ignoring the
+ init_region, instead of clipping to it, so the entire backing
+ pixmap was cleared on every begin_paint()
+ (gdk_window_begin_paint_region): Hmm, the same list-walking bug
+ was in here again, the loop kept using the same GtkWindowPaint
+ over and over.
+ (gdk_window_begin_paint_region): Fix a bug where we had two
+ x_offset instead of x_offset and y_offset
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): get composite drawable
+ before we get the image.
+ (gdk_draw_drawable): get the composite before we draw the drawable.
+ (gdk_drawable_real_get_composite_drawable): default
+ get_composite_drawable implementation that returns the drawable
+ itself
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Add
+ get_composite_drawable virtual function
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix a cheesy
+ list-walking bug
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_x11_draw_drawable): Add a hack to
+ make this work if the source drawable is a GdkDrawableImplX11
+ instead of a public drawable type. This is really broken; the
+ problem is that GdkDrawable needs a virtual method get_xid(), but
+ of course that doesn't work in practice. Enter RTTI.
+
+ Also, improve mismatched depth message.
+
+ * gdk/gdkpixmap.c (gdk_pixmap_get_image): Implement get_image for
+ GdkPixmap
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_drawable_impl_x11_class_init):
+ install _gdk_x11_get_image as our implementation of get_image
+
+ * gdk/x11/gdkimage-x11.c (gdk_image_get): Rename to
+ _gdk_x11_get_image and export for use in gdkdrawable-x11.c
+
+ * gdk/gdkimage.c (gdk_image_get): Make this just a wrapper around
+ gdk_drawable_get_image
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): call virtual get_image
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Virtualize
+ get_image
+
+ * gtk/gtktreestore.c (gtk_tree_store_get_node): remove weird
+ trailing semicolon after for loop
+
Mon Oct 23 12:07:57 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_set_style_internal): Fix problem
+2000-10-23 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testtext.c: Re-enable the "find" dialog
+
+ * gtk/testgtk.c: Add test for gdk_drawable_get_image
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix bug where
+ the arguments to gdk_draw_drawable were in the wrong order
+ (gdk_window_paint_init_bg): This function was ignoring the
+ init_region, instead of clipping to it, so the entire backing
+ pixmap was cleared on every begin_paint()
+ (gdk_window_begin_paint_region): Hmm, the same list-walking bug
+ was in here again, the loop kept using the same GtkWindowPaint
+ over and over.
+ (gdk_window_begin_paint_region): Fix a bug where we had two
+ x_offset instead of x_offset and y_offset
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): get composite drawable
+ before we get the image.
+ (gdk_draw_drawable): get the composite before we draw the drawable.
+ (gdk_drawable_real_get_composite_drawable): default
+ get_composite_drawable implementation that returns the drawable
+ itself
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Add
+ get_composite_drawable virtual function
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix a cheesy
+ list-walking bug
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_x11_draw_drawable): Add a hack to
+ make this work if the source drawable is a GdkDrawableImplX11
+ instead of a public drawable type. This is really broken; the
+ problem is that GdkDrawable needs a virtual method get_xid(), but
+ of course that doesn't work in practice. Enter RTTI.
+
+ Also, improve mismatched depth message.
+
+ * gdk/gdkpixmap.c (gdk_pixmap_get_image): Implement get_image for
+ GdkPixmap
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_drawable_impl_x11_class_init):
+ install _gdk_x11_get_image as our implementation of get_image
+
+ * gdk/x11/gdkimage-x11.c (gdk_image_get): Rename to
+ _gdk_x11_get_image and export for use in gdkdrawable-x11.c
+
+ * gdk/gdkimage.c (gdk_image_get): Make this just a wrapper around
+ gdk_drawable_get_image
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): call virtual get_image
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Virtualize
+ get_image
+
+ * gtk/gtktreestore.c (gtk_tree_store_get_node): remove weird
+ trailing semicolon after for loop
+
Mon Oct 23 12:07:57 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_set_style_internal): Fix problem
+2000-10-23 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testtext.c: Re-enable the "find" dialog
+
+ * gtk/testgtk.c: Add test for gdk_drawable_get_image
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix bug where
+ the arguments to gdk_draw_drawable were in the wrong order
+ (gdk_window_paint_init_bg): This function was ignoring the
+ init_region, instead of clipping to it, so the entire backing
+ pixmap was cleared on every begin_paint()
+ (gdk_window_begin_paint_region): Hmm, the same list-walking bug
+ was in here again, the loop kept using the same GtkWindowPaint
+ over and over.
+ (gdk_window_begin_paint_region): Fix a bug where we had two
+ x_offset instead of x_offset and y_offset
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): get composite drawable
+ before we get the image.
+ (gdk_draw_drawable): get the composite before we draw the drawable.
+ (gdk_drawable_real_get_composite_drawable): default
+ get_composite_drawable implementation that returns the drawable
+ itself
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Add
+ get_composite_drawable virtual function
+
+ * gdk/gdkwindow.c (gdk_window_begin_paint_region): Fix a cheesy
+ list-walking bug
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_x11_draw_drawable): Add a hack to
+ make this work if the source drawable is a GdkDrawableImplX11
+ instead of a public drawable type. This is really broken; the
+ problem is that GdkDrawable needs a virtual method get_xid(), but
+ of course that doesn't work in practice. Enter RTTI.
+
+ Also, improve mismatched depth message.
+
+ * gdk/gdkpixmap.c (gdk_pixmap_get_image): Implement get_image for
+ GdkPixmap
+
+ * gdk/x11/gdkdrawable-x11.c (gdk_drawable_impl_x11_class_init):
+ install _gdk_x11_get_image as our implementation of get_image
+
+ * gdk/x11/gdkimage-x11.c (gdk_image_get): Rename to
+ _gdk_x11_get_image and export for use in gdkdrawable-x11.c
+
+ * gdk/gdkimage.c (gdk_image_get): Make this just a wrapper around
+ gdk_drawable_get_image
+
+ * gdk/gdkdraw.c (gdk_drawable_get_image): call virtual get_image
+
+ * gdk/gdkdrawable.h (struct _GdkDrawableClass ): Virtualize
+ get_image
+
+ * gtk/gtktreestore.c (gtk_tree_store_get_node): remove weird
+ trailing semicolon after for loop
+
Mon Oct 23 12:07:57 2000 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_set_style_internal): Fix problem
+2000-10-23 Havoc Pennington <hp@redhat.com>
+
+ * gtk/gtk-sections.txt: remove GtkTextBTree
+
+ * gtk/text_widget.sgml: Overview of the text widget
+
+ * gtk/gtk-docs.sgml: Change to using categories for the toplevel
+ organization of the reference entries. We'll add an alphabetical
+ index eventually. The category way is a lot easier for people who
+ aren't familiar with the widgets. Removed objects_grouped.sgml
+ from gtk-docs.sgml for now, it doesn't seem useful anymore.
+
+ * gtk/objects_grouped.sgml: Add a section for deprecated
+ objects; add a section for the TextView object collection
+
Wed Oct 18 11:01:12 2000 Owen Taylor <otaylor@redhat.com>
* gtk/Makefile.am gdk-pixbuf/Makefile.am: Fix typo
GTKDOC_LD=$(LIBTOOL) --mode=link $(CC)
content_files = \
- objects_grouped.sgml
+ objects_grouped.sgml \
+ text_widget.sgml
####################################
# Everything below here is generic #
<!entity index-Object-Tree SYSTEM "sgml/tree_index.sgml">
<!entity index-Objects-Grouped SYSTEM "objects_grouped.sgml">
+<!entity gtk-TextWidget SYSTEM "text_widget.sgml">
]>
<book id="index">
<bookinfo>
</varlistentry>
</variablelist>
</para>
+
>k-General;
>k-Feature-Test-Macros;
>k-Graphics-Contexts;
>k-Types;
>k-Bindings;
>k-Standard-Enumerations;
+
</chapter>
- <chapter id="gtkobjects" role="no-toc">
+ <chapter id="gtkobjects" role="no-toc">
<title>GTK+ Widgets and Objects</title>
- &index-Objects-Grouped;
- &GtkAccelLabel;
- &GtkAdjustment;
- &GtkAlignment;
- &GtkArrow;
- &GtkAspectFrame;
- &GtkButtonBox;
- &GtkBin;
- &GtkBox;
- &GtkButton;
- &GtkCalendar;
- &GtkCheckButton;
- &GtkCheckMenuItem;
- &GtkCList;
- &GtkColorSelection;
- &GtkColorSelectionDialog;
- &GtkCombo;
- &GtkContainer;
- &GtkCTree;
- &GtkCurve;
- &GtkData;
- &GtkDialog;
- &GtkDrawingArea;
- &GtkEditable;
- &GtkEntry;
- &GtkEventBox;
- &GtkFileSelection;
- &GtkFixed;
- &GtkFontSelection;
- &GtkFontSelectionDialog;
- &GtkFrame;
- &GtkGammaCurve;
- &GtkHandleBox;
- &GtkHButtonBox;
- &GtkHBox;
- &GtkHPaned;
- &GtkHRuler;
- &GtkHScale;
- &GtkHScrollbar;
- &GtkHSeparator;
- &GtkImage;
- &GtkIMContext;
- &GtkIMMulticontext;
- &GtkInputDialog;
- &GtkInvisible;
- &GtkItem;
- &GtkItemFactory;
- &GtkLabel;
- &GtkLayout;
- &GtkList;
- &GtkListItem;
- &GtkMenu;
- &GtkMenuBar;
- &GtkMenuItem;
- &GtkMenuShell;
- &GtkMisc;
- &GtkNotebook;
- &GtkObject;
- &GtkOptionMenu;
- &GtkPacker;
- &GtkPaned;
- &GtkPixmap;
- &GtkPlug;
- &GtkPreview;
- &GtkProgress;
- &GtkProgressBar;
- &GtkRadioButton;
- &GtkRadioMenuItem;
- &GtkRange;
- &GtkRuler;
- &GtkScale;
- &GtkScrollbar;
- &GtkScrolledWindow;
- &GtkSeparator;
- &GtkSocket;
- &GtkSpinButton;
- &GtkStatusbar;
- &GtkTable;
- &GtkTearoffMenuItem;
- &GtkText;
- &GtkTextBuffer;
- >k-GtkTextIter;
- >k-GtkTextMark;
- &GtkTextTag;
- &GtkTextTagTable;
- &GtkTextView;
- &GtkTipsQuery;
- &GtkToggleButton;
- &GtkToolbar;
- &GtkTooltips;
- &GtkTree;
- &GtkTreeItem;
- &GtkVButtonBox;
- &GtkVBox;
- &GtkViewport;
- &GtkVPaned;
- &GtkVRuler;
- &GtkVScale;
- &GtkVScrollbar;
- &GtkVSeparator;
- &GtkWidget;
- &GtkWindow;
- </chapter>
-
- <chapter id="gtk-index">
- <title>Index</title>
<sect1>
<title>Object Hierarchy</title>
&index-Object-Tree;
</sect1>
+
+ <sect1 id="WindowWidgets">
+ <title>Windows</title>
+ &GtkDialog;
+ &GtkInvisible;
+ &GtkPlug;
+ &GtkWindow;
+ </sect1>
+
+ <sect1 id="DisplayWidgets">
+ <title>Display Widgets</title>
+ &GtkAccelLabel;
+ &GtkImage;
+ &GtkLabel;
+ &GtkProgressBar;
+ &GtkStatusbar;
+ </sect1>
+
+ <sect1 id="ButtonWidgets">
+ <title>Buttons and Toggles</title>
+ &GtkButton;
+ &GtkCheckButton;
+ &GtkRadioButton;
+ &GtkToggleButton;
+ </sect1>
+
+ <sect1 id="NumericEntry">
+ <title>Numeric/Text Data Entry</title>
+ &GtkEntry;
+ &GtkHScale;
+ &GtkSpinButton;
+ &GtkVScale;
+ </sect1>
+
+ <sect1 id="TextWidgetObjects">
+ <title>Multiline Text Editor</title>
+ >k-TextWidget;
+ >k-GtkTextIter;
+ >k-GtkTextMark;
+ &GtkText;
+ &GtkTextBuffer;
+ &GtkTextTag;
+ &GtkTextTagTable;
+ &GtkTextView;
+ </sect1>
+
+
+ <sect1 id="MenusAndCombos">
+ <title>Menus, Combo Box, Toolbar</title>
+ &GtkCheckMenuItem;
+ &GtkCombo;
+ &GtkItemFactory;
+ &GtkMenu;
+ &GtkMenuBar;
+ &GtkMenuItem;
+ &GtkMenuShell;
+ &GtkOptionMenu;
+ &GtkRadioMenuItem;
+ &GtkTearoffMenuItem;
+ &GtkToolbar;
+ </sect1>
+
+ <sect1 id="SelectorWidgets">
+ <title>Selectors (File/Font/Color/Input Devices)</title>
+ &GtkColorSelection;
+ &GtkColorSelectionDialog;
+ &GtkFileSelection;
+ &GtkFontSelection;
+ &GtkFontSelectionDialog;
+ &GtkInputDialog;
+ </sect1>
+
+ <sect1 id="LayoutContainers">
+ <title>Layout Containers</title>
+ &GtkAlignment;
+ &GtkAspectFrame;
+ &GtkHBox;
+ &GtkHButtonBox;
+ &GtkFixed;
+ &GtkHPaned;
+ &GtkLayout;
+ &GtkNotebook;
+ &GtkTable;
+ &GtkVButtonBox;
+ &GtkVBox;
+ &GtkVPaned;
+ </sect1>
+
+ <sect1 id="Ornaments">
+ <title>Ornaments</title>
+ &GtkFrame;
+ &GtkHSeparator;
+ &GtkVSeparator;
+ </sect1>
+
+ <sect1 id="ScrollingWidgets">
+ <title>Scrolling</title>
+ &GtkHScrollbar;
+ &GtkScrolledWindow;
+ &GtkVScrollbar;
+ </sect1>
+
+ <sect1 id="MiscObjects">
+ <title>Miscellaneous</title>
+ &GtkAdjustment;
+ &GtkArrow;
+ &GtkCalendar;
+ &GtkDrawingArea;
+ &GtkEventBox;
+ &GtkHandleBox;
+ &GtkIMContext;
+ &GtkIMMulticontext;
+ &GtkTooltips;
+ &GtkViewport;
+ </sect1>
+
+ <sect1 id="AbstractObjects">
+ <title>Abstract Base Classes</title>
+ &GtkBin;
+ &GtkBox;
+ &GtkContainer;
+ &GtkEditable;
+ &GtkButtonBox;
+ &GtkMisc;
+ &GtkObject;
+ &GtkPaned;
+ &GtkRange;
+ &GtkScale;
+ &GtkScrollbar;
+ &GtkSeparator;
+ &GtkWidget;
+ </sect1>
+
+ <sect1 id="PlugSocket">
+ <title>Cross-process Embedding</title>
+ &GtkSocket;
+ </sect1>
+
+ <sect1 id="DeprecatedObjects">
+ <title>Deprecated</title>
+ &GtkCList;
+ &GtkCTree;
+ &GtkCurve;
+ &GtkData;
+ &GtkGammaCurve;
+ &GtkHRuler;
+ &GtkItem;
+ &GtkList;
+ &GtkListItem;
+ &GtkPacker;
+ &GtkPixmap;
+ &GtkPreview;
+ &GtkProgress;
+ &GtkRuler;
+ &GtkTipsQuery;
+ &GtkTree;
+ &GtkTreeItem;
+ &GtkVRuler;
+ </sect1>
+
</chapter>
+
</book>
<SECTION>
<FILE>gtktextbuffer</FILE>
-GtkTextBTree
<TITLE>GtkTextBuffer</TITLE>
gtk_text_buffer_new
gtk_text_buffer_get_line_count
<emphasis>Data Entry Widgets</emphasis>
<link linkend="GtkEntry">GtkEntry</link>
- <link linkend="GtkText">GtkText</link>
<link linkend="GtkSpinButton">GtkSpinButton</link>
+ <link linkend="GtkTextView">GtkTextView</link>
<link linkend="GtkOptionMenu">GtkOptionMenu</link>
<link linkend="GtkCombo">GtkCombo</link>
<link linkend="GtkHScale">GtkHScale</link>
<link linkend="GtkVScale">GtkVScale</link>
+
<emphasis>Lists & Trees</emphasis>
<link linkend="GtkCList">GtkCList</link>
<link linkend="GtkCTree">GtkCTree</link>
<link linkend="GtkList">GtkList</link>
<link linkend="GtkListItem">GtkListItem</link>
- <link linkend="GtkTree">GtkTree</link>
- <link linkend="GtkTreeItem">GtkTreeItem</link>
+
+<emphasis>Text Widget Objects</emphasis>
+ <link linkend="GtkTextBuffer">GtkTextBuffer</link>
+ <link linkend="GtkTextTag">GtkTextTag</link>
+ <link linkend="GtkTextTagTable">GtkTextTagTable</link>
+ <link linkend="GtkTextView">GtkTextView</link>
<emphasis>Tooltips</emphasis>
<link linkend="GtkTooltips">GtkTooltips</link>
<link linkend="GtkTipsQuery">GtkTipsQuery</link>
</literallayout></entry>
+
<entry><literallayout>
<emphasis>Menus & Menu Bars</emphasis>
<link linkend="GtkMenuBar">GtkMenuBar</link>
<link linkend="GtkColorSelection">GtkColorSelection</link>
<link linkend="GtkFontSelection">GtkFontSelection</link>
</literallayout></entry>
+
<entry><literallayout>
<emphasis>Abstract Base Classes</emphasis>
<link linkend="GtkWidget">GtkWidget</link>
<link linkend="GtkItemFactory">GtkItemFactory</link>
<link linkend="GtkInvisible">GtkInvisible</link>
</literallayout></entry>
+
+<entry><literallayout>
+<emphasis>Deprecated Objects</emphasis>
+ <link linkend="GtkText">GtkText</link>
+ <link linkend="GtkTree">GtkTree</link>
+ <link linkend="GtkTreeItem">GtkTreeItem</link>
+</literallayout></entry>
</row>
</tbody></tgroup></informaltable>
--- /dev/null
+<refentry id="TextWidget" revision="18 Oct 2000">
+<refmeta>
+<refentrytitle>Text Widget Overview</refentrytitle>
+<manvolnum>3</manvolnum>
+<refmiscinfo>GTK Library</refmiscinfo>
+</refmeta>
+
+<refnamediv>
+<refname>Text Widget Overview</refname><refpurpose>Overview of <link linkend="GtkTextBuffer">GtkTextBuffer</link>, <link linkend="GtkTextView">GtkTextView</link>, and friends</refpurpose>
+</refnamediv>
+
+<refsect1>
+<title>Conceptual Overview</title>
+
+<para>
+GTK+ has an extremely powerful framework for multiline text editing. The
+primary objects involved in the process are <link
+linkend="GtkTextBuffer">GtkTextBuffer</link>, which represents the text being
+edited, and <link linkend="GtkTextView">GtkTextView</link>, a widget which can
+display a <link linkend="GtkTextBuffer">GtkTextBuffer</link>. Each buffer can be
+displayed by any number of views.
+</para>
+
+<para>
+Text in a buffer can be marked with <firstterm>tags</firstterm>. A tag is an
+attribute that can be applied to some range of text. For example, a tag might be
+called "bold" and make the text inside the tag bold. However, the tag concept is
+more general than that; tags don't have to affect appearance. They can instead
+affect change the behavior of mouse and key presses, "lock" a range of text so
+the user can't edit it, or countless other things. A tag is represented by a
+<link linkend="GtkTextTag">GtkTextTag</link> object. One <link
+linkend="GtkTextTag">GtkTextTag</link> can be applied to any number of text
+ranges in any number of buffers.
+</para>
+
+<para>
+Each tag is stored in a <link
+linkend="GtkTextTagTable">GtkTextTagTable</link>. A tag table defines a set of
+tags that can be used together. Each buffer has one tag table associated with
+it; only tags from that tag table can be used with the buffer. A single tag
+table can be shared between multiple buffers, however.
+</para>
+
+<para>
+Tags can have names, which is convenient sometimes (for example, you can name
+your tag that makes things bold "bold"), but they can also be anonymous (which
+is convenient if you're creating tags on-the-fly).
+</para>
+
+<para>
+Most text manipulation is accomplished with <firstterm>iterators</firstterm>,
+represented by a <link linkend="GtkTextIter">GtkTextIter</link>. An iterator
+represents a position in the text buffer. <link
+linkend="GtkTextIter">GtkTextIter</link> is a struct designed to be allocated on
+the stack; it's guaranteed to be copiable by value and never contain any
+heap-allocated data. Iterators are not valid indefinitely; whenever the buffer
+is modified in a way that affects the number of characters in the buffer, all
+outstanding iterators become invalid. (Note that deleting 5 characters and then
+reinserting 5 still invalidates iterators, though you end up with the same
+number of characters).
+</para>
+
+<para>
+Because of this, iterators can't be used to preserve positions across buffer
+modifications. To preserve a position, the <link
+linkend="GtkTextMark">GtkTextMark</link> object is ideal. You can think of a
+mark as an invisible cursor or insertion point; it floats in the buffer, saving
+a position. If the text surrounding the mark is deleted, the mark remains in the
+position the text once occupied; if text is inserted at the mark, the mark ends
+up either to the left or to the right of the new text, depending on its
+<firstterm>gravity</firstterm>. The standard text cursor in left-to-right
+languages is a mark with right gravity, because it stays to the right of
+inserted text.
+</para>
+
+<para>
+Like tags, marks can be either named or anonymous. There are two marks built-in
+to <link linkend="GtkTextBuffer">GtkTextBuffer</link>; these are named
+<literal>"insert"</literal> and <literal>"selection_bound"</literal> and refer
+to the insertion point and the boundary of the selection which is not the
+insertion point, respectively. If no text is selected, these two marks will be
+in the same position. You can manipulate what is selected and where the cursor
+appears by moving these marks around.
+
+<footnote>
+<para>
+If you want to place the cursor in response to a user action, be sure to use
+gtk_text_buffer_place_cursor(), which moves both at once without causing a
+temporary selection (moving one then the other temporarily selects the range in
+between the old and new positions).
+</para>
+</footnote>
+</para>
+
+</refsect1>
+
+
+<refsect1>
+<title>Simple Example</title>
+
+<para>
+The simplest usage of <link linkend="GtkTextView">GtkTextView</link>
+might look like this:
+<programlisting>
+
+ /* Get a buffer (it's a GObject, not a GtkObject, so we own a reference
+ * after this). Passing NULL as argument causes an empty tag table to be
+ * automatically created.
+ */
+
+ buffer = gtk_text_buffer_new (NULL);
+
+ view = gtk_text_view_new_with_buffer (buffer);
+
+ /* view holds a reference now */
+ g_object_unref (G_OBJECT (buffer));
+
+ /* Now you might put the view in a container and display it on the
+ * screen; when the user edits the text, signals on the buffer
+ * will be emitted, such as "changed", "insert_text", and so on.
+ */
+</programlisting>
+</para>
+
+</refsect1>
+
+</refentry>
<!-- ##### SECTION Short_Description ##### -->
+Stores attributed text for display in a <link
+linkend="GtkTextView">GtkTextView</link>
<!-- ##### SECTION Long_Description ##### -->
+
+<para>
+You may wish to begin by reading the <link linkend="TextWidget">text widget
+conceptual overview</link> which gives an overview of all the objects and data
+types related to the text widget and how they work together.
+</para>
+
<para>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
-
+#GtkTextView, #GtkTextIter, #GtkTextMark
</para>
<!-- ##### STRUCT GtkTextBTree ##### -->
<!-- ##### SECTION Title ##### -->
-gtktextiter
+GtkTextIter
<!-- ##### SECTION Short_Description ##### -->
-
+Text buffer iterator
<!-- ##### SECTION Long_Description ##### -->
+<para>
+You may wish to begin by reading the <link linkend="TextWidget">text widget
+conceptual overview</link> which gives an overview of all the objects and data
+types related to the text widget and how they work together.
+</para>
+
<para>
</para>
<!-- ##### SECTION Title ##### -->
-gtktextmark
+GtkTextMark
<!-- ##### SECTION Short_Description ##### -->
+A position in the buffer preserved across buffer modifications
<!-- ##### SECTION Long_Description ##### -->
<para>
+You may wish to begin by reading the <link linkend="TextWidget">text widget
+conceptual overview</link> which gives an overview of all the objects and data
+types related to the text widget and how they work together.
+</para>
+<para>
+A #GtkTextMark is like a bookmark in a text buffer; it preserves a position in
+the text. You can convert the mark to an iterator using
+gtk_text_buffer_get_iter_at_mark(). Unlike iterators, marks remain valid across
+buffer mutations, because their behavior is defined when text is inserted or
+deleted. When text containing a mark is deleted, the mark remains in the
+position originally occupied by the deleted text. When text is inserted at a
+mark, a mark with <firstterm>left gravity</firstterm> will be moved to the
+beginning of the newly-inserted text, and a mark with <firstterm>right
+gravity</firstterm> will be moved to the end.
+
+<footnote>
+<para>
+"left" and "right" here refer to logical direction (left is the toward the start
+of the buffer); in some languages such as Hebrew the logically-leftmost text is
+not actually on the left when displayed.
+</para>
+</footnote>
+</para>
+
+<para>
+Marks are reference counted, but the reference count only controls the validity
+of the memory; marks can be deleted from the buffer at any time with
+gtk_text_buffer_delete_mark(). Once deleted from the buffer, a mark is
+essentially useless.
+</para>
+
+<para>
+Marks optionally have names; these can be convenient to avoid passing the
+#GtkTextMark object around.
+</para>
+
+<para>
+Marks are typically created using the gtk_text_buffer_create_mark() function.
</para>
<!-- ##### SECTION See_Also ##### -->
<!-- ##### SECTION Short_Description ##### -->
+A tag that can be applied to text in a <link linkend="GtkTextBuffer">GtkTextBuffer</link>
<!-- ##### SECTION Long_Description ##### -->
+<para>
+You may wish to begin by reading the <link linkend="TextWidget">text widget
+conceptual overview</link> which gives an overview of all the objects and data
+types related to the text widget and how they work together.
+</para>
+
<para>
</para>
<!-- ##### SECTION Short_Description ##### -->
+Collection of tags that can be used together
<!-- ##### SECTION Long_Description ##### -->
+<para>
+You may wish to begin by reading the <link linkend="TextWidget">text widget
+conceptual overview</link> which gives an overview of all the objects and data
+types related to the text widget and how they work together.
+</para>
+
<para>
</para>
GtkTextView
<!-- ##### SECTION Short_Description ##### -->
-
+Widget that displays a <link linkend="GtkTextBuffer">GtkTextBuffer</link>
<!-- ##### SECTION Long_Description ##### -->
+<para>
+You may wish to begin by reading the <link linkend="TextWidget">text widget
+conceptual overview</link> which gives an overview of all the objects and data
+types related to the text widget and how they work together.
+</para>
+
<para>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
-
+#GtkTextBuffer, #GtkTextIter
</para>
<!-- ##### STRUCT GtkTextView ##### -->
#include "gdkinternals.h"
#include "gdkwindow.h"
+static GdkDrawable* gdk_drawable_real_get_composite_drawable (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gint *composite_x_offset,
+ gint *composite_y_offset);
+
+static void gdk_drawable_class_init (GdkDrawableClass *klass);
+
GType
gdk_drawable_get_type (void)
{
sizeof (GdkDrawableClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
- (GClassInitFunc) NULL,
+ (GClassInitFunc) gdk_drawable_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GdkDrawable),
return object_type;
}
+static void
+gdk_drawable_class_init (GdkDrawableClass *klass)
+{
+ klass->get_composite_drawable = gdk_drawable_real_get_composite_drawable;
+}
+
/* Manipulation of drawables
*/
gint width,
gint height)
{
+ GdkDrawable *composite;
+ gint composite_x_offset = 0;
+ gint composite_y_offset = 0;
+
g_return_if_fail (GDK_IS_DRAWABLE (drawable));
g_return_if_fail (src != NULL);
g_return_if_fail (GDK_IS_GC (gc));
height = real_height;
}
- GDK_DRAWABLE_GET_CLASS (drawable)->draw_drawable (drawable, gc, src,
- xsrc, ysrc, xdest, ydest,
+
+ composite =
+ GDK_DRAWABLE_GET_CLASS (src)->get_composite_drawable (src,
+ xsrc, ysrc,
+ width, height,
+ &composite_x_offset,
+ &composite_y_offset);
+
+
+ GDK_DRAWABLE_GET_CLASS (drawable)->draw_drawable (drawable, gc, composite,
+ xsrc - composite_x_offset,
+ ysrc - composite_y_offset,
+ xdest, ydest,
width, height);
+
+ g_object_unref (G_OBJECT (composite));
}
void
gint y,
PangoGlyphString *glyphs)
{
-
g_return_if_fail (GDK_IS_DRAWABLE (drawable));
g_return_if_fail (GDK_IS_GC (gc));
}
+GdkImage*
+gdk_drawable_get_image (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GdkDrawable *composite;
+ gint composite_x_offset = 0;
+ gint composite_y_offset = 0;
+ GdkImage *retval;
+
+ g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
+ g_return_val_if_fail (x >= 0, NULL);
+ g_return_val_if_fail (y >= 0, NULL);
+ g_return_val_if_fail (width >= 0, NULL);
+ g_return_val_if_fail (height >= 0, NULL);
+
+ composite =
+ GDK_DRAWABLE_GET_CLASS (drawable)->get_composite_drawable (drawable,
+ x, y,
+ width, height,
+ &composite_x_offset,
+ &composite_y_offset);
+
+ retval = GDK_DRAWABLE_GET_CLASS (composite)->get_image (composite,
+ x - composite_x_offset,
+ y - composite_y_offset,
+ width, height);
+
+ g_object_unref (G_OBJECT (composite));
+
+ return retval;
+}
+
+static GdkDrawable*
+gdk_drawable_real_get_composite_drawable (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gint *composite_x_offset,
+ gint *composite_y_offset)
+{
+ g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
+
+ *composite_x_offset = 0;
+ *composite_y_offset = 0;
+
+ return GDK_DRAWABLE (g_object_ref (G_OBJECT (drawable)));
+}
GdkColormap* (*get_colormap) (GdkDrawable *drawable);
GdkVisual* (*get_visual) (GdkDrawable *drawable);
+
+ GdkImage* (*get_image) (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
+ GdkDrawable* (*get_composite_drawable) (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gint *composite_x_offset,
+ gint *composite_y_offset);
+
};
GType gdk_drawable_get_type (void);
gint y,
PangoLayout *layout);
+GdkImage* gdk_drawable_get_image (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
g_object_unref (G_OBJECT (image));
}
+
+GdkImage*
+gdk_image_get (GdkWindow *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_val_if_fail (GDK_IS_DRAWABLE (window), NULL);
+ g_return_val_if_fail (x >= 0, NULL);
+ g_return_val_if_fail (y >= 0, NULL);
+ g_return_val_if_fail (width >= 0, NULL);
+ g_return_val_if_fail (height >= 0, NULL);
+
+ return gdk_drawable_get_image (window, x, y, width, height);
+}
gint *width,
gint *height);
+static GdkImage* gdk_pixmap_get_image (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
+
static GdkVisual* gdk_pixmap_real_get_visual (GdkDrawable *drawable);
static gint gdk_pixmap_real_get_depth (GdkDrawable *drawable);
static void gdk_pixmap_real_set_colormap (GdkDrawable *drawable,
drawable_class->set_colormap = gdk_pixmap_real_set_colormap;
drawable_class->get_colormap = gdk_pixmap_real_get_colormap;
drawable_class->get_visual = gdk_pixmap_real_get_visual;
+ drawable_class->get_image = gdk_pixmap_get_image;
}
static void
return gdk_drawable_get_colormap (((GdkPixmapObject*)drawable)->impl);
}
+static GdkImage*
+gdk_pixmap_get_image (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ g_return_val_if_fail (GDK_IS_PIXMAP (drawable), NULL);
+
+ return gdk_drawable_get_image (((GdkPixmapObject*)drawable)->impl,
+ x, y, width, height);
+}
+
#define PACKED_COLOR(c) ((((c)->red & 0xff) << 8) | ((c)->green & 0xff) | ((c)->blue >> 8))
static GdkPixmap *
#include "gdkinternals.h"
#include "gdk.h" /* For gdk_rectangle_union() */
#include "gdkpixmap.h"
+#include "gdkdrawable.h"
+#include "gdkpixmap.h"
#ifndef USE_BACKING_STORE
#ifndef GDK_WINDOWING_WIN32
gint width,
gint height);
+static GdkImage* gdk_window_get_image (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
static void gdk_window_real_get_size (GdkDrawable *drawable,
gint *width,
static void gdk_window_real_set_colormap (GdkDrawable *drawable,
GdkColormap *cmap);
static GdkColormap* gdk_window_real_get_colormap (GdkDrawable *drawable);
-
+
+static GdkDrawable* gdk_window_get_composite_drawable (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gint *composite_x_offset,
+ gint *composite_y_offset);
+
static void gdk_window_free_paint_stack (GdkWindow *window);
static void gdk_window_init (GdkWindowObject *window);
drawable_class->set_colormap = gdk_window_real_set_colormap;
drawable_class->get_colormap = gdk_window_real_get_colormap;
drawable_class->get_visual = gdk_window_real_get_visual;
+ drawable_class->get_image = gdk_window_get_image;
+ drawable_class->get_composite_drawable = gdk_window_get_composite_drawable;
}
static void
GdkRegion *init_region)
{
GdkGC *tmp_gc;
-
+
tmp_gc = gdk_window_get_bg_gc (window, paint);
+
+ gdk_region_offset (init_region,
+ - paint->x_offset,
+ - paint->y_offset);
+ gdk_gc_set_clip_region (tmp_gc, init_region);
+
gdk_draw_rectangle (paint->pixmap, tmp_gc, TRUE, 0, 0, -1, -1);
gdk_gc_unref (tmp_gc);
}
-
+
+
+#include "x11/gdkx.h"
void
gdk_window_begin_paint_region (GdkWindow *window,
GdkRegion *region)
if (new_rect.width > old_rect.width || new_rect.height > old_rect.height)
{
- paint->pixmap = gdk_pixmap_new (window, new_rect.width, new_rect.height, -1);
+ paint->pixmap = gdk_pixmap_new (window,
+ new_rect.width, new_rect.height, -1);
tmp_gc = gdk_gc_new (paint->pixmap);
gdk_draw_drawable (paint->pixmap, tmp_gc, tmp_paint->pixmap,
- 0, 0, old_rect.width, old_rect.height,
- old_rect.x - new_rect.x, old_rect.y - new_rect.y);
+ 0, 0,
+ old_rect.x - new_rect.x, old_rect.y - new_rect.y,
+ old_rect.width, old_rect.height);
gdk_gc_unref (tmp_gc);
gdk_drawable_unref (tmp_paint->pixmap);
tmp_list = private->paint_stack;
while (tmp_list)
{
- tmp_paint = private->paint_stack->data;
+ tmp_paint = tmp_list->data;
gdk_region_subtract (init_region, tmp_paint->region);
tmp_paint->pixmap = paint->pixmap;
tmp_paint->x_offset = paint->x_offset;
- tmp_paint->y_offset = paint->x_offset;
-
+ tmp_paint->y_offset = paint->y_offset;
+
tmp_list = tmp_list->next;
}
}
tmp_list = private->paint_stack;
while (tmp_list)
{
- tmp_paint = private->paint_stack->data;
+ tmp_paint = tmp_list->data;
gdk_region_subtract (init_region, tmp_paint->region);
tmp_list = tmp_list->next;
if (!gdk_region_empty (init_region))
gdk_window_paint_init_bg (window, paint, init_region);
+
gdk_region_destroy (init_region);
private->paint_stack = g_slist_prepend (private->paint_stack, paint);
{
GdkWindowPaint *tmp_paint = tmp_list->data;
gdk_region_subtract (tmp_paint->region, paint->region);
-
+
tmp_list = tmp_list->next;
}
}
RESTORE_GC (gc);
}
+static GdkDrawable*
+gdk_window_get_composite_drawable (GdkDrawable *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gint *composite_x_offset,
+ gint *composite_y_offset)
+{
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ GdkWindowPaint *paint;
+ GdkRegion *buffered_region;
+ GSList *tmp_list;
+ GdkPixmap *buffer;
+ GdkPixmap *tmp_pixmap;
+ GdkRectangle rect;
+ GdkRegion *rect_region;
+ GdkGC *tmp_gc;
+ gint windowing_x_offset, windowing_y_offset;
+ gint buffer_x_offset, buffer_y_offset;
+
+ if (GDK_WINDOW_DESTROYED (window) || private->paint_stack == NULL)
+ {
+ /* No backing store */
+ _gdk_windowing_window_get_offsets (window,
+ composite_x_offset,
+ composite_y_offset);
+
+ return GDK_DRAWABLE (g_object_ref (G_OBJECT (window)));
+ }
+
+ buffered_region = NULL;
+ buffer = NULL;
+
+ /* All GtkWindowPaint structs have the same pixmap and offsets, just
+ * get the first one. (should probably be cleaned up so that the
+ * pixmap is stored in the window)
+ */
+ paint = private->paint_stack->data;
+ buffer = paint->pixmap;
+ buffer_x_offset = paint->x_offset;
+ buffer_y_offset = paint->y_offset;
+
+ tmp_list = private->paint_stack;
+ while (tmp_list != NULL)
+ {
+ paint = tmp_list->data;
+
+ if (buffered_region == NULL)
+ buffered_region = gdk_region_copy (paint->region);
+ else
+ gdk_region_union (buffered_region, paint->region);
+
+ tmp_list = g_slist_next (tmp_list);
+ }
+
+ /* See if the buffered part is overlapping the part we want
+ * to get
+ */
+ rect.x = x;
+ rect.y = y;
+ rect.width = width;
+ rect.height = height;
+
+ rect_region = gdk_region_rectangle (&rect);
+
+ gdk_region_intersect (buffered_region, rect_region);
+
+ gdk_region_destroy (rect_region);
+
+ if (gdk_region_empty (buffered_region))
+ {
+ gdk_region_destroy (buffered_region);
+
+ _gdk_windowing_window_get_offsets (window,
+ composite_x_offset,
+ composite_y_offset);
+
+ return GDK_DRAWABLE (g_object_ref (G_OBJECT (window)));
+ }
+
+ tmp_pixmap = gdk_pixmap_new (window,
+ width, height,
+ -1);
+
+ tmp_gc = gdk_gc_new (tmp_pixmap);
+
+ _gdk_windowing_window_get_offsets (window,
+ &windowing_x_offset,
+ &windowing_y_offset);
+
+ /* Copy the current window contents */
+ gdk_draw_drawable (tmp_pixmap,
+ tmp_gc,
+ private->impl,
+ x - windowing_x_offset,
+ y - windowing_y_offset,
+ 0, 0,
+ width, height);
+
+ /* Make buffered_region relative to the tmp_pixmap */
+ gdk_region_offset (buffered_region,
+ - x,
+ - y);
+
+ /* Set the clip mask to avoid drawing over non-buffered areas of
+ * tmp_pixmap.
+ */
+
+ gdk_gc_set_clip_region (tmp_gc, buffered_region);
+ gdk_region_destroy (buffered_region);
+
+ /* Draw backing pixmap onto the tmp_pixmap, offsetting
+ * appropriately.
+ */
+ gdk_draw_drawable (tmp_pixmap,
+ tmp_gc,
+ buffer,
+ x - buffer_x_offset,
+ y - buffer_y_offset,
+ 0, 0,
+ width, height);
+
+ /* Set these to location of tmp_pixmap within the window */
+ *composite_x_offset = x;
+ *composite_y_offset = y;
+
+ g_object_unref (G_OBJECT (tmp_gc));
+
+ return tmp_pixmap;
+}
+
static void
gdk_window_draw_drawable (GdkDrawable *drawable,
GdkGC *gc,
{
GdkWindowObject *private = (GdkWindowObject *)drawable;
OFFSET_GC (gc);
-
+
if (GDK_WINDOW_DESTROYED (drawable))
return;
-
+
+ /* If we have a backing pixmap draw to that */
if (private->paint_stack)
{
GdkWindowPaint *paint = private->paint_stack->data;
- gdk_draw_drawable (paint->pixmap, gc, src, xsrc, ysrc,
+ gdk_draw_drawable (paint->pixmap, gc,
+ src, xsrc, ysrc,
xdest - x_offset, ydest - y_offset, width, height);
}
else
- gdk_draw_drawable (private->impl, gc, src, xsrc, ysrc,
+ gdk_draw_drawable (private->impl, gc,
+ src, xsrc, ysrc,
xdest - x_offset, ydest - y_offset,
width, height);
+
RESTORE_GC (gc);
}
return gdk_drawable_get_colormap (((GdkWindowObject*)drawable)->impl);
}
+
+static GdkImage*
+gdk_window_get_image (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ gint x_offset, y_offset;
+
+ g_return_val_if_fail (GDK_IS_WINDOW (drawable), NULL);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return NULL;
+
+ /* If we're here, a composite image was not necessary, so
+ * we can ignore the paint stack.
+ */
+
+ _gdk_windowing_window_get_offsets (drawable, &x_offset, &y_offset);
+
+ return gdk_drawable_get_image (((GdkWindowObject*)drawable)->impl,
+ x - x_offset,
+ y - y_offset,
+ width, height);
+}
/* Code for dirty-region queueing
*/
static gint gdk_x11_get_depth (GdkDrawable *drawable);
+static GdkVisual* gdk_x11_get_visual (GdkDrawable *drawable);
+
static void gdk_drawable_impl_x11_class_init (GdkDrawableImplX11Class *klass);
static gpointer parent_class = NULL;
drawable_class->get_colormap = gdk_x11_get_colormap;
drawable_class->get_depth = gdk_x11_get_depth;
+ drawable_class->get_visual = gdk_x11_get_visual;
+
+ drawable_class->get_image = _gdk_x11_get_image;
}
/*****************************************************
int src_depth = gdk_drawable_get_depth (src);
int dest_depth = gdk_drawable_get_depth (drawable);
GdkDrawableImplX11 *impl;
-
+ GdkDrawableImplX11 *src_impl;
+
impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+
+ if (GDK_IS_DRAWABLE_IMPL_X11 (src))
+ src_impl = GDK_DRAWABLE_IMPL_X11 (src);
+ else
+ src_impl = NULL;
if (src_depth == 1)
{
XCopyArea (impl->xdisplay,
- GDK_DRAWABLE_XID (src),
+ src_impl ? src_impl->xid : GDK_DRAWABLE_XID (src),
impl->xid,
GDK_GC_GET_XGC (gc),
xsrc, ysrc,
else if (dest_depth != 0 && src_depth == dest_depth)
{
XCopyArea (impl->xdisplay,
- GDK_DRAWABLE_XID (src),
+ src_impl ? src_impl->xid : GDK_DRAWABLE_XID (src),
impl->xid,
GDK_GC_GET_XGC (gc),
xsrc, ysrc,
xdest, ydest);
}
else
- g_warning ("Attempt to copy between drawables of mismatched depths!\n");
+ g_warning ("Attempt to draw a drawable with depth %d to a drawable with depth %d",
+ src_depth, dest_depth);
}
static void
return gdk_drawable_get_depth (GDK_DRAWABLE_IMPL_X11 (drawable)->wrapper);
}
+static GdkVisual*
+gdk_x11_get_visual (GdkDrawable *drawable)
+{
+ return gdk_drawable_get_visual (GDK_DRAWABLE_IMPL_X11 (drawable)->wrapper);
+}
gc->clip_y_origin = 0;
x11_gc->dirty_mask |= GDK_GC_DIRTY_CLIP;
-}
+}
void
gdk_gc_set_clip_region (GdkGC *gc,
}
GdkImage*
-gdk_image_get (GdkWindow *window,
- gint x,
- gint y,
- gint width,
- gint height)
+_gdk_x11_get_image (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
GdkImage *image;
GdkImagePrivateX11 *private;
+ GdkDrawableImplX11 *impl;
+ GdkVisual *visual;
+
+ g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_X11 (drawable), NULL);
- g_return_val_if_fail (GDK_IS_DRAWABLE (window), NULL);
+ visual = gdk_drawable_get_visual (drawable);
- if (GDK_IS_WINDOW (window) && GDK_WINDOW_DESTROYED (window))
- return NULL;
+ if (visual == NULL)
+ {
+ g_warning ("To get the image from a drawable, the drawable "
+ "must have a visual and colormap; calling "
+ "gtk_drawable_set_colormap() on a drawable "
+ "created without a colormap should solve this problem");
+ return NULL;
+ }
+
+ impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+
image = g_object_new (gdk_image_get_type (), NULL);
private = PRIVATE_DATA (image);
private->xdisplay = gdk_display;
private->ximage = XGetImage (private->xdisplay,
- GDK_DRAWABLE_XID (window),
+ impl->xid,
x, y, width, height,
AllPlanes, ZPixmap);
image->type = GDK_IMAGE_NORMAL;
- image->visual = gdk_window_get_visual (window);
+ image->visual = visual;
image->width = width;
image->height = height;
image->depth = private->ximage->depth;
GdkPixmap *pixmap;
GdkDrawableImplX11 *draw_impl;
GdkPixmapImplX11 *pix_impl;
+ GdkColormap *cmap;
g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
g_return_val_if_fail ((window != NULL) || (depth != -1), NULL);
pix_impl->width = width;
pix_impl->height = height;
GDK_PIXMAP_OBJECT (pixmap)->depth = depth;
+
+ if (window)
+ {
+ cmap = gdk_drawable_get_colormap (window);
+ if (cmap)
+ gdk_drawable_set_colormap (pixmap, cmap);
+ }
gdk_xid_table_insert (&GDK_PIXMAP_XID (pixmap), pixmap);
-
+
return pixmap;
}
void gdk_window_add_colormap_windows (GdkWindow *window);
+GdkImage* _gdk_x11_get_image (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
/* Please see gdkwindow.c for comments on how to use */
Window gdk_window_xid_at (Window base,
gint bx,
indices[i]);
if (node == NULL)
return NULL;
- };
+ }
return (GtkTreeNode) node;
}
gtk_widget_destroy (window);
}
+/*
+ * Test for getting an image from a drawable
+ */
+
+struct GetImageData
+{
+ GtkWidget *src;
+ GtkWidget *snap;
+ GtkWidget *sw;
+};
+
+static void
+take_snapshot (GtkWidget *button,
+ gpointer data)
+{
+ struct GetImageData *gid = data;
+ GdkRectangle visible;
+ int width_fraction;
+ int height_fraction;
+ GdkGC *gc;
+ GdkGC *black_gc;
+ GdkColor color = { 0, 30000, 0, 0 };
+ GdkRectangle target;
+ GdkImage *shot;
+
+ /* Do some begin_paint_rect on some random rects, draw some
+ * distinctive stuff into those rects, then take the snapshot.
+ * figure out whether any rects were overlapped and report to
+ * user.
+ */
+
+ visible = gid->sw->allocation;
+
+ visible.x = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value;
+ visible.y = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value;
+
+ width_fraction = visible.width / 4;
+ height_fraction = visible.height / 4;
+
+ gc = gdk_gc_new (gid->src->window);
+ black_gc = gid->src->style->black_gc;
+
+ gdk_gc_set_rgb_fg_color (gc, &color);
+
+
+ target.x = visible.x + width_fraction;
+ target.y = visible.y + height_fraction * 3;
+ target.width = width_fraction;
+ target.height = height_fraction / 2;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x = visible.x + width_fraction;
+ target.y = visible.y + height_fraction;
+ target.width = width_fraction;
+ target.height = height_fraction;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x = visible.x + width_fraction * 3;
+ target.y = visible.y + height_fraction;
+ target.width = width_fraction / 2;
+ target.height = height_fraction;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x = visible.x + width_fraction * 2;
+ target.y = visible.y + height_fraction * 2;
+ target.width = width_fraction / 4;
+ target.height = height_fraction / 4;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x += target.width / 2;
+ target.y += target.width / 2;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ /* Screen shot area */
+
+ target.x = visible.x + width_fraction * 1.5;
+ target.y = visible.y + height_fraction * 1.5;
+ target.width = width_fraction * 2;
+ target.height = height_fraction * 2;
+
+ shot = gdk_drawable_get_image (gid->src->window,
+ target.x, target.y,
+ target.width, target.height);
+
+ gtk_image_set_from_image (GTK_IMAGE (gid->snap),
+ shot, NULL);
+
+ g_object_unref (G_OBJECT (shot));
+
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+
+ gdk_draw_rectangle (gid->src->window,
+ gid->src->style->black_gc,
+ FALSE,
+ target.x, target.y,
+ target.width, target.height);
+
+ g_object_unref (G_OBJECT (gc));
+}
+
+static gint
+image_source_expose (GtkWidget *da,
+ GdkEventExpose *event,
+ gpointer data)
+{
+ int x = event->area.x;
+ GdkColor red = { 0, 65535, 0, 0 };
+ GdkColor green = { 0, 0, 65535, 0 };
+ GdkColor blue = { 0, 0, 0, 65535 };
+ GdkGC *gc;
+
+ gc = gdk_gc_new (event->window);
+
+ while (x < (event->area.x + event->area.width))
+ {
+ switch (x % 7)
+ {
+ case 0:
+ case 1:
+ case 2:
+ gdk_gc_set_rgb_fg_color (gc, &red);
+ break;
+
+ case 3:
+ case 4:
+ case 5:
+ gdk_gc_set_rgb_fg_color (gc, &green);
+ break;
+
+ case 6:
+ case 7:
+ case 8:
+ gdk_gc_set_rgb_fg_color (gc, &blue);
+ break;
+
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ gdk_draw_line (event->window,
+ gc,
+ x, event->area.y,
+ x, event->area.y + event->area.height);
+
+ ++x;
+ }
+
+ g_object_unref (G_OBJECT (gc));
+
+ return TRUE;
+}
+
+static void
+create_get_image (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (!window)
+ {
+ GtkWidget *sw;
+ GtkWidget *src;
+ GtkWidget *snap;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *button;
+ struct GetImageData *gid;
+
+ gid = g_new (struct GetImageData, 1);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect (GTK_OBJECT (window),
+ "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &window);
+
+ gtk_object_set_data_full (GTK_OBJECT (window),
+ "testgtk-get-image-data",
+ gid,
+ g_free);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+
+ gid->sw = sw;
+
+ gtk_widget_set_usize (sw, 400, 400);
+
+ src = gtk_drawing_area_new ();
+ gtk_widget_set_usize (src, 10000, 10000);
+
+ gtk_signal_connect (GTK_OBJECT (src),
+ "expose_event",
+ GTK_SIGNAL_FUNC (image_source_expose),
+ gid);
+
+ gid->src = src;
+
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw),
+ src);
+
+ gtk_box_pack_start (GTK_BOX (vbox),
+ sw, TRUE, TRUE, 0);
+
+
+ hbox = gtk_hbox_new (FALSE, 3);
+
+ snap = gtk_widget_new (GTK_TYPE_IMAGE, NULL);
+
+ gid->snap = snap;
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_widget_set_usize (sw, 300, 300);
+
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), snap);
+
+ gtk_box_pack_end (GTK_BOX (hbox), sw, FALSE, FALSE, 5);
+
+ button = gtk_button_new_with_label ("Get image from drawable");
+
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (take_snapshot),
+ gid);
+
+ gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (window);
+ }
+}
+
/*
* Label Demo
*/
{ "font selection", create_font_selection },
{ "gamma curve", create_gamma_curve },
{ "handle box", create_handle_box },
+ { "image from drawable", create_get_image },
{ "image", create_image },
{ "item factory", create_item_factory },
{ "labels", create_labels },
GtkWidget *search_text;
GtkTextBuffer *buffer;
-#if 0
-
dialog = gtk_dialog_new_with_buttons ("Search",
GTK_WINDOW (view->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_BUTTON_CLOSE,
GTK_RESPONSE_NONE, NULL);
+
buffer = gtk_text_buffer_new (NULL);
/* FIXME memory leak once buffer is a GObject */
gtk_widget_grab_focus (search_text);
gtk_widget_show_all (dialog);
-#endif
}
static void
GtkTextIter iter;
GtkTextIter start, end;
GtkWidget *dialog;
+ int i;
/* remove tag from whole buffer */
gtk_text_buffer_get_bounds (buffer->buffer, &start, &end);
gtk_text_buffer_get_mark (buffer->buffer,
"insert"));
-
+ i = 0;
if (*str != '\0')
{
GtkTextIter match_start, match_end;
while (gtk_text_iter_forward_search (&iter, str, TRUE, FALSE,
&match_start, &match_end))
{
+ ++i;
gtk_text_buffer_apply_tag (buffer->buffer, buffer->found_text_tag,
&match_start, &match_end);
}
}
-#if 0
dialog = gtk_message_dialog_new (GTK_WINDOW (view->window),
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
GTK_OBJECT (dialog));
gtk_widget_show (dialog);
-#endif
}
static void
gtk_widget_destroy (window);
}
+/*
+ * Test for getting an image from a drawable
+ */
+
+struct GetImageData
+{
+ GtkWidget *src;
+ GtkWidget *snap;
+ GtkWidget *sw;
+};
+
+static void
+take_snapshot (GtkWidget *button,
+ gpointer data)
+{
+ struct GetImageData *gid = data;
+ GdkRectangle visible;
+ int width_fraction;
+ int height_fraction;
+ GdkGC *gc;
+ GdkGC *black_gc;
+ GdkColor color = { 0, 30000, 0, 0 };
+ GdkRectangle target;
+ GdkImage *shot;
+
+ /* Do some begin_paint_rect on some random rects, draw some
+ * distinctive stuff into those rects, then take the snapshot.
+ * figure out whether any rects were overlapped and report to
+ * user.
+ */
+
+ visible = gid->sw->allocation;
+
+ visible.x = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value;
+ visible.y = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value;
+
+ width_fraction = visible.width / 4;
+ height_fraction = visible.height / 4;
+
+ gc = gdk_gc_new (gid->src->window);
+ black_gc = gid->src->style->black_gc;
+
+ gdk_gc_set_rgb_fg_color (gc, &color);
+
+
+ target.x = visible.x + width_fraction;
+ target.y = visible.y + height_fraction * 3;
+ target.width = width_fraction;
+ target.height = height_fraction / 2;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x = visible.x + width_fraction;
+ target.y = visible.y + height_fraction;
+ target.width = width_fraction;
+ target.height = height_fraction;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x = visible.x + width_fraction * 3;
+ target.y = visible.y + height_fraction;
+ target.width = width_fraction / 2;
+ target.height = height_fraction;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x = visible.x + width_fraction * 2;
+ target.y = visible.y + height_fraction * 2;
+ target.width = width_fraction / 4;
+ target.height = height_fraction / 4;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x += target.width / 2;
+ target.y += target.width / 2;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ /* Screen shot area */
+
+ target.x = visible.x + width_fraction * 1.5;
+ target.y = visible.y + height_fraction * 1.5;
+ target.width = width_fraction * 2;
+ target.height = height_fraction * 2;
+
+ shot = gdk_drawable_get_image (gid->src->window,
+ target.x, target.y,
+ target.width, target.height);
+
+ gtk_image_set_from_image (GTK_IMAGE (gid->snap),
+ shot, NULL);
+
+ g_object_unref (G_OBJECT (shot));
+
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+
+ gdk_draw_rectangle (gid->src->window,
+ gid->src->style->black_gc,
+ FALSE,
+ target.x, target.y,
+ target.width, target.height);
+
+ g_object_unref (G_OBJECT (gc));
+}
+
+static gint
+image_source_expose (GtkWidget *da,
+ GdkEventExpose *event,
+ gpointer data)
+{
+ int x = event->area.x;
+ GdkColor red = { 0, 65535, 0, 0 };
+ GdkColor green = { 0, 0, 65535, 0 };
+ GdkColor blue = { 0, 0, 0, 65535 };
+ GdkGC *gc;
+
+ gc = gdk_gc_new (event->window);
+
+ while (x < (event->area.x + event->area.width))
+ {
+ switch (x % 7)
+ {
+ case 0:
+ case 1:
+ case 2:
+ gdk_gc_set_rgb_fg_color (gc, &red);
+ break;
+
+ case 3:
+ case 4:
+ case 5:
+ gdk_gc_set_rgb_fg_color (gc, &green);
+ break;
+
+ case 6:
+ case 7:
+ case 8:
+ gdk_gc_set_rgb_fg_color (gc, &blue);
+ break;
+
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ gdk_draw_line (event->window,
+ gc,
+ x, event->area.y,
+ x, event->area.y + event->area.height);
+
+ ++x;
+ }
+
+ g_object_unref (G_OBJECT (gc));
+
+ return TRUE;
+}
+
+static void
+create_get_image (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (!window)
+ {
+ GtkWidget *sw;
+ GtkWidget *src;
+ GtkWidget *snap;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *button;
+ struct GetImageData *gid;
+
+ gid = g_new (struct GetImageData, 1);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect (GTK_OBJECT (window),
+ "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &window);
+
+ gtk_object_set_data_full (GTK_OBJECT (window),
+ "testgtk-get-image-data",
+ gid,
+ g_free);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+
+ gid->sw = sw;
+
+ gtk_widget_set_usize (sw, 400, 400);
+
+ src = gtk_drawing_area_new ();
+ gtk_widget_set_usize (src, 10000, 10000);
+
+ gtk_signal_connect (GTK_OBJECT (src),
+ "expose_event",
+ GTK_SIGNAL_FUNC (image_source_expose),
+ gid);
+
+ gid->src = src;
+
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw),
+ src);
+
+ gtk_box_pack_start (GTK_BOX (vbox),
+ sw, TRUE, TRUE, 0);
+
+
+ hbox = gtk_hbox_new (FALSE, 3);
+
+ snap = gtk_widget_new (GTK_TYPE_IMAGE, NULL);
+
+ gid->snap = snap;
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_widget_set_usize (sw, 300, 300);
+
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), snap);
+
+ gtk_box_pack_end (GTK_BOX (hbox), sw, FALSE, FALSE, 5);
+
+ button = gtk_button_new_with_label ("Get image from drawable");
+
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (take_snapshot),
+ gid);
+
+ gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (window);
+ }
+}
+
/*
* Label Demo
*/
{ "font selection", create_font_selection },
{ "gamma curve", create_gamma_curve },
{ "handle box", create_handle_box },
+ { "image from drawable", create_get_image },
{ "image", create_image },
{ "item factory", create_item_factory },
{ "labels", create_labels },
GtkWidget *search_text;
GtkTextBuffer *buffer;
-#if 0
-
dialog = gtk_dialog_new_with_buttons ("Search",
GTK_WINDOW (view->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_BUTTON_CLOSE,
GTK_RESPONSE_NONE, NULL);
+
buffer = gtk_text_buffer_new (NULL);
/* FIXME memory leak once buffer is a GObject */
gtk_widget_grab_focus (search_text);
gtk_widget_show_all (dialog);
-#endif
}
static void
GtkTextIter iter;
GtkTextIter start, end;
GtkWidget *dialog;
+ int i;
/* remove tag from whole buffer */
gtk_text_buffer_get_bounds (buffer->buffer, &start, &end);
gtk_text_buffer_get_mark (buffer->buffer,
"insert"));
-
+ i = 0;
if (*str != '\0')
{
GtkTextIter match_start, match_end;
while (gtk_text_iter_forward_search (&iter, str, TRUE, FALSE,
&match_start, &match_end))
{
+ ++i;
gtk_text_buffer_apply_tag (buffer->buffer, buffer->found_text_tag,
&match_start, &match_end);
}
}
-#if 0
dialog = gtk_message_dialog_new (GTK_WINDOW (view->window),
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
GTK_OBJECT (dialog));
gtk_widget_show (dialog);
-#endif
}
static void
projects / gtk4.git / commitdiff